/* @internal */
名域 ts {
    导出 函数 获取原始节点Id(n: 节点_) {
        n = 获取原始节点(n);
        返回 n ? 获取节点Id(n) : 0;
    }

    导出 接口 外部模块信息_ {
        外部导入: (导入声明_ | 导入从声明_)[];
        导出名称: 标识符_[];
    }

    导出 函数 收集外部模块信息(源文件: 源文件_): 外部模块信息_ {
        常量 外部导入: (导入声明_ | 导入从声明_)[] = [];
        变量 导出名称: 标识符_[];
        循环 (常量 n 属于 源文件.语句组) {
            假如 (n.种类) {
                若是 语法_.导入声明_:
                    外部导入.压入(<导入声明_>n);
                    跳出;
                若是 语法_.导入从声明_:
                    外部导入.压入(<导入从声明_>n);
                    跳出;
                若是 语法_.程序声明_:{                            
                    循环 (常量 nn 属于 (<程序声明_>n).语句组) {
                        假如 (nn.种类) {
                            若是 语法_.常量语句_:
                                循环执行((<常量语句_>nn).声明组, i => {
                                    如果 (是导出标识符(i.名称.文本)) {
                                        追加(导出名称, i.名称);
                                    }
                                })
                                跳出;
                            若是 语法_.变量语句_:
                                循环执行((<变量语句_>nn).声明组, i => {
                                    如果 (是导出标识符(i.名称.文本)) {
                                        追加(导出名称, i.名称);
                                    }
                                })
                                跳出;
                            若是 语法_.类型别名声明_:
                            若是 语法_.类型声明_:
                            若是 语法_.函数声明_:
                            若是 语法_.接口声明_:
                            若是 语法_.结构声明_:
                                如果 ((<类型声明_ | 结构声明_ | 接口声明_ | 类型别名声明_ | 函数声明_>nn).名称 && 是导出标识符((<类型声明_ | 结构声明_ | 接口声明_ | 类型别名声明_ | 函数声明_>nn).名称!.文本)) {
                                    追加(导出名称!, (<类型声明_ | 结构声明_ | 接口声明_ | 类型别名声明_ | 函数声明_>nn).名称!);
                                }
                                跳出;
                        }
                    }
                }
            }
        }
        返回 { 外部导入, 导出名称 };
    }
}